home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / cprog.EXE / C11.TXT < prev    next >
Text File  |  1996-07-05  |  22KB  |  548 lines
  1. C Dili - Konu 11
  2.  
  3. Structure ve Union'lar
  4.  
  5. STRUCTURE NEDIR?
  6.  
  7. Not: Structure'un tam tercumesi herhalde 'Yapi' olacak..
  8.  
  9. Bir structure, kullanici tarafindan tanimlanmis bir veri tipidir. Su ana
  10. kadar kullandigimiz veri tiplerinden cok daha karmasik olanlari,
  11. tanimlayabilirsiniz. Bir structure, daha once tanimlanmis olan veri
  12. tiplerinin bir araya gelmis halidir - ki bu veri tiplerine, daha once
  13. tanimladigimiz structure'lar da dahildir. Bu tanimi rahat anlamanin bir
  14. yolu, structure'un, veriyi kullaniciya yada o programi kullanacak olan
  15. kisiye daha rahat bir sekilde gruplamak icin kullanildigini
  16. belirtebiliriz.  Her zamanki gibi, bir seyi anlamanin en iyi yolu,
  17. orneklere bakmaktir...
  18.  
  19. STRUCT1.C:
  20. ================================================================
  21.  
  22. main()
  23. {
  24.  
  25. struct {
  26.    char bas_harf;  /* Soyadin bas harfi   */
  27.    int yas;        /* cocugun yasi        */
  28.    int not;        /* okulda not ortalamasi (100 uzerinden) */
  29.    } oglan,kiz;
  30.  
  31.    oglan.bas_harf = 'R';
  32.    oglan.yas = 15;
  33.    oglan.not = 75;
  34.  
  35.    kiz.yas = oglan.yas - 1;  /* o, oglandan bir yas kucuk */
  36.    kiz.not = 82;
  37.    kiz.bas_harf = 'H';
  38.  
  39.    printf("%d yasindaki %c'nin aldigi not, %d dir.\n",
  40.            kiz.yas, kiz.bas_harf, kiz.not);
  41.  
  42.    printf("%d yasindaki %c'nin aldigi not, %d dir.\n",
  43.            oglan.yas, oglan.bas_harf, oglan.not);
  44. }
  45. ================================================================
  46.  
  47. Program, bir structure tanimi ile basliyor. "struct" kelimesinden sonra,
  48. kume isaretleri arasinda bazi basit degiskenler goruyorsunuz. Bu
  49. degiskenler, bu structure'i olusturan parcalardir. Kapanan kume
  50. isaretinden sonra, iki tane degisken ismi goruyorsunuz: "oglan" ve "kiz".
  51. Bu structure'un tanimina gore, "oglan" artik, 3 elemandan olusan bir
  52. degiskendir. Bunlar "bas_harf", "yas", ve "not" dur, ve herbiri, kendi
  53. tiplerinde bir veriyi saklayabilirler. "kiz" degiskeninin de ayni 3
  54. elemani vardir, fakat bu baska bir degiskendir. Yani, 6 tane basit
  55. degisken tanimlamis olduk..
  56.  
  57. TEK BIR BIRLESIK DEGISKEN
  58.  
  59. "oglan" degiskenini daha yakindan izleyelim. Daha once soyledigimiz gibi,
  60. "oglan" in her elemani, basit birer degiskendir, ve bu tip bir degiskenin
  61. kullanilabilecegi heryerde kullanilabilir. Ornegin, "yas" elemani, bir
  62. tamsayi degiskenidir, dolayisiyla, bir C programinda bir tamsayi
  63. degiskeninin kullanilabilecegi her yerde kullanilabilir. Hesaplamalarda,
  64. bir sayac olarak, I/O islemlerinde vs. Yegane problem, bu "yas" isimli
  65. basit degiskeni "oglan" ile beraber kullanmamiz gerekir. Bunu yapmak
  66. icinde, ikisini de yaziyoruz, ve arasina bir nokta isareti koyuyoruz.
  67. Oyleyse, tum degisken ismi olan "oglan.yas",  "oglan" degiskeninin "yas"
  68. sahasi oluyor.. Bu yapiyi, bu sahaya erismek istedigimiz heryerde
  69. kullanabiliriz. Hatta, sadece "oglan" yada "yas" dememiz, kabul
  70. edilmeyecektir. Tek baslarina, isimlerin bir manasi yoktur.
  71.  
  72.  
  73. DEGISKENLERE DEGER ATAMA
  74.  
  75. Yukardaki tanimlamayi kullanarak, "oglan" ve "kiz" 'in her uc sahasina
  76. ("bas_harf","yas","not") degerler ayabiliriz. Dikkat etmeniz gereken bir
  77. nokta, "oglan.bas_harf"'in bir "char" tipi oldugudur. Bu nedenle,
  78. programda karakter verisine atanmistir. "oglan" in geri kalan iki sahasi
  79. da, tanimlandiklari 'tiplerde', degerlere atanir.. Sonra, "kiz" isimli
  80. degiskenin 3 sahasi da, degerlere atanir. Burada atama sirasinin fark
  81. etmeyecegini gosterebilmek icin, farkli bir sira izlenmistir.
  82.  
  83. BU DEGERLERI NASIL KULLANABILIRIZ??
  84.  
  85. Alti basit degiskenimizin her elemanina veri atadiktan sonra, onlarla
  86. diledigimizi yapabiliriz. Bu ilk ornegi basit tutmak icin, biz sadece
  87. degerlerini ekrana yazdiriyoruz. "printf" satirinin alistigimizdan farkli
  88. olmadigini goreceksiniz.
  89.  
  90. Structure'lar, programi daha kolay yazmak ve anlamak icin, cok faydali bir
  91. gruplama metodudur. Bu ilk ornek cok basit oldugundan, size structure'un
  92. gercek degerini gostermekten acizdir, fakat okumaya devam ederseniz,
  93. structure'un gercekten faydali oldugunu goreceksiniz..
  94.  
  95.  
  96. BIR STRUCTURE DIZISI
  97.  
  98. STRUCT2.C:
  99. ================================================================
  100. main()
  101. {
  102. struct {
  103.    char bas_harf;
  104.    int yas;
  105.    int not;
  106.    } cocuklar[12];
  107.  
  108. int indeks;
  109.  
  110.    for (indeks = 0;indeks < 12;indeks++) {
  111.       cocuklar[indeks].bas_harf = 'A' + indeks;
  112.       cocuklar[indeks].yas = 16;
  113.       cocuklar[indeks].not = 84;
  114.    }
  115.  
  116.    cocuklar[3].yas = cocuklar[5].yas = 17;
  117.    cocuklar[2].not = cocuklar[6].not = 92;
  118.    cocuklar[4].not = 57;
  119.  
  120.    for (indeks = 0;indeks < 12;indeks++)
  121.       printf("%c , %d yasindadir ve  notu %d dur.\n",
  122.              cocuklar[indeks].bas_harf, cocuklar[indeks].yas,
  123.              cocuklar[indeks].not);
  124. }
  125. ================================================================
  126.  
  127. Bu programda, bir oncekinin ayni structure tanimini kullaniyor. Fakat
  128. tanimladigi, 12 tane "cocuklar" isimli  degisken oluyor. Yani bu program
  129. 12 * 3 = 36 tane basit degiskenden olusuyor. Bunlarin herbiri, kendi
  130. tiplerinde veri tasiyabilirler. Ayrica for dongulerinde kullanmak icin
  131. "indeks" isimli bir basit degisken de tanimliyoruz.
  132.  
  133. Her sahaya bir deger atamak icin, bir for dongusu kullaniyoruz, ve
  134. donguden her gecis, bu 3 sahaya deger atanmasini sagliyor. Gercek hayatta
  135. bu metod, veri atanmasi icin pek uygun olmayacaktir. Ornegin veriler
  136. kutukten okunup, degerlerine atanabilir. Bunu basit bir veri tabani
  137. uygulamasi olarak gorebilirsiniz, gercekten de oyledir.
  138.  
  139. Bundan sonra, birkac elemana, nasil atanacagini gostermek amaci ile,
  140. degerler atiyoruz. 
  141.  
  142. PASCAL PROGRAMCILARINA NOT:
  143.  
  144. Pascal dilinde bir butun RECORD'un tek bir komut ile kopyalayabilirsiniz. 
  145. Bu, C de mumkun degildir. Structure'un her elemanini tek tek kopyalamaniz
  146. lazimdir. Lisan gelismelere ugradikca, bu da degisecek bir noktadir.
  147. Hatta, bazi yeni derleyiciler, structure'un atanmasini yapabiliyor.
  148. Derleyicinizin kilavuzuna bir bakin..
  149.  
  150.  
  151. SONUNDA BUTUN NETICELERI GOSTERIYORUZ
  152.  
  153. Son birkac satirda da, formatlanmis bir sekilde verilerin yazilmasini
  154. goruyorsunuz. 
  155.  
  156. POINTER'LAR VE STRUCTURE'LARI BIR ARADA KULLANMAK
  157.  
  158. STRUCT3.C:
  159. ================================================================
  160. main()
  161. {
  162. struct {
  163.    char bas_harf;
  164.    int yas;
  165.    int not;
  166.    } cocuklar[12],*point;
  167.  
  168. int index;
  169.  
  170.    for (index = 0;index < 12;index++) {
  171.       point = cocuklar + index;
  172.       point->bas_harf = 'A' + index;
  173.       point->yas = 16;
  174.       point->not = 84;
  175.    }
  176.  
  177.    cocuklar[3].yas = cocuklar[5].yas = 17;
  178.    cocuklar[2].not = cocuklar[6].not = 92;
  179.    cocuklar[4].not = 57;
  180.  
  181.    for (index = 0;index < 12;index++) {
  182.       point = cocuklar + index;
  183.       printf("%c , %d yasindadir ve notu %d dur.\n",
  184.              (*point).bas_harf, cocuklar[index].yas,
  185.              point->not);
  186.    }
  187. }
  188. ================================================================
  189.  
  190. Bu program, bir once gordugumuz programin neredeyse aynisi, fakat bu, bazi
  191. islemler icin pointer'lardan yararlaniyor.
  192.  
  193. Ilk fark, structure'un tanimlanmasindan sonraki degisken tanimlarinda goze
  194. carpiyor. Burada, "point" isimli bir pointer tanimliyoruz, ve tipine de,
  195. bu pointer'in tipi olarak veriyoruz. Bu pointer'in herhangi baska bir cins
  196. degisken tipini 'gostermesine' calismak, yalnis olur. C dilinde bu
  197. kisitlama icin cok yerinde bir neden vardir, ve bunu gelecek paragraflarda
  198. gorecegiz. 
  199.  
  200. Daha sonraki degisiklik ise, veri sahalarina erismek icin pointer
  201. kullandigimiz dongude ortaya cikiyor. "cocuklar" kendi basina bir pointer
  202. gorevi yaptigindan, "point" i "kids" in adresine atayabiliriz. 
  203.  
  204. POINTER ARITMETIGI
  205.  
  206. "point" e bir ekledigimiz zaman, "cocuklar" dizisindeki ikinci elemanini
  207. gosteriyoruz. Sistem, bu structure'un 3 tane degiskenden olustugunu ve
  208. butun structure'u hafizada tutmak icin ne kadar yer gerektigini bilir. Bu
  209. sayede, "point"e bir ekle dedigimizde, dizideki bir sonraki elemana varmak
  210. icin kac hafiza elemani a$ilmasi gerekiyorsa, o kadar ekler. Ornegin,
  211. "point" e 4 ekleseydik, sistem, "point" e 4 kere structure'un boyu kadar
  212. yer adres atlatirdi. Bu sebeple, pointerlar, tanimlandiklari tipten baska
  213. bir tip icin kullanilamazlar.
  214.  
  215. Simdi programimiza geri donelim. Bir onceki paragraftan da
  216. anlayabileceginiz gibi, dongunun icinde ilerledikce, pointer'in degeri
  217. artarak her dizi elemaninin baslangicini teker teker gosterecektir. Bu
  218. sayede, pointer ile bu structure'un degisik elemanlarina erisebiliriz. C
  219. dilinde bir structure'un elemanlarina pointer ile erismek o kadar cok
  220. kullanilir ki, bunu gostermek icin ozel bir metod gelistirilmistir.
  221. "point->bas_harf" metodunu kullanmak, "(*point).bas_harf" metodunu
  222. kullanmak ile ayni manadadir. "->" sembolu, bir eksi isareti ve bir
  223. buyuktur isareti ile elde edilir.
  224.  
  225. Pointer, bir structure'u gosterdigine gore, kullanirken, o structure'un
  226. hangi degiskenine erismek istedigimizi belirtmemiz gereklidir. Gordugunuz
  227. gibi, bir structure'un elemanlarina erismek icin degisik yollar vardir, ve
  228. programin sonunda, ciktiyi saglayan "for" dongusunde, 3 degisik metod
  229. goruyorsunuz. Bu kotu bir programlama teknigi olarak kabul edilirdi, fakat
  230. burada size her ucunun de ayni neticeyi verdigini gostermek amaci ile
  231. yapilmistir. Bu program, tam olarak kavrayabilmeniz icin, herhalde bir
  232. sure incelemenizi gerektirecektir.
  233.  
  234. IC ICE VE ISIMLI STRUCTURE'LAR
  235.  
  236. ICICE.C:
  237. ================================================================
  238. main()
  239. {
  240. struct insan {
  241.    char isim[25];
  242.    int yas;
  243.    char durum;        /* E = Evli , B = Bekar */
  244. } ;
  245.  
  246. struct tumveri {
  247.    int not;
  248.    struct insan ozellikler;
  249.    char yemek[25];
  250. } ogrenci[53];
  251.  
  252. struct tumveri hoca,asistan;
  253.  
  254. hoca.not = 94;
  255. hoca.ozellikler.yas = 34;
  256. hoca.ozellikler.durum = 'E';
  257. strcpy(hoca.ozellikler.isim,"Mary Smith");
  258. strcpy(hoca.yemek,"Salamli sandvic");
  259.  
  260. asistan.ozellikler.yas = 87;
  261. asistan.ozellikler.durum = 'E';
  262. strcpy(asistan.ozellikler.isim,"Old Lady Brown");
  263. asistan.not = 73;
  264. strcpy(asistan.yemek,"Yogurt ve ekmek");
  265.  
  266. ogrenci[1].ozellikler.yas = 15;
  267. ogrenci[1].ozellikler.durum = 'B';
  268. strcpy(ogrenci[1].ozellikler.isim,"Billy Boston");
  269. strcpy(ogrenci[1].yemek,"Findik ezmesi");
  270. ogrenci[1].not = 77;
  271.  
  272. ogrenci[7].ozellikler.yas = 14;
  273. ogrenci[12].not = 87;
  274.  
  275. }
  276. ================================================================
  277.  
  278. Simdiye kadar gordugumuz structure'lar basit fakat kullanisli idi.
  279. Yuzlerce yada binlerce elemandan olusan structure'lar tanimlamak
  280. mumkundur, fakat butun hepsini siradan tanimlamak yerine hierarsik bir
  281. duzen kullanmak, programcinin lehine olur.
  282.  
  283. Ilk structure'da 3 eleman vardir, fakat arkasindan bir degisken ismi
  284. gelmemektedir. Yani, biz sadece bir structure tanimladik, ve hicbir
  285. degisken tanimlamadik. Basina "insan" ismini koydugumuzdan, bu
  286. structure'un ismi de "insan" dir. Bu isim, bu structure duzenini kullanmak
  287. istedigimizde kullanilir, fakat bu structure degiskenlerinden biri, bu
  288. isimle kullanilamaz. Dolayisi ile, yeni bir tip tanimlamis olduk - ayni
  289. "char" yada "int" gibi, ve neredeyse ayni sekilde, bu yeni tipi
  290. kullanabiliriz. 
  291.  
  292. Bundan sonraki structure tanimlamasi, 3 sahadan olusuyor. Ikinci sahasi,
  293. daha once tanimladigimiz "insan" structure'unu kullaniyor. "insan" tipi
  294. degiskenin ismine "ozellikler" ismini veriyoruz. Yeni structure, iki tane
  295. basit degisken de kullaniyor, "not" isimli tamsayi degiskeni, 
  296. "yemek[25]" isimli bir karakter dizisi, ve "ozellikler" isimli bir
  297. structure. "ozellikler" in icinde 3 degisken oldugu icin, bu structure 5
  298. degisken tanimlamis oluyor. Bu structure'a da, "tumveri" ismini veriyoruz,
  299. ki bu da bir baska tip tanimlanmasidir. Sonunda, 53 degiskenlik, ve
  300. "tumveri" tipinde bir dizi tanimliyoruz, ve buna "ogrenci" ismini
  301. veriyoruz. Sayet bunlar sizin icin anlasilir idi ise, her birine deger
  302. atanabilen toplam olarak 53 kere 5 degisken tanimladigimizi gorursunuz.
  303.  
  304. IKI DEGISKEN DAHA
  305.  
  306. Bir degisken tipi tanimimiz olduguna gore, onu iki degisken daha
  307. tanimlamada kullanabiliriz. "hoca" ve "assistan" isimli degiskenler de
  308. "tumveri" tipindedir, her birinin icine bilgi konulabilecegimiz , 5 er
  309. sahadan olusurlar.
  310.  
  311. BU SAHALARIN BAZILARINI KULLANALIM
  312.  
  313. Bundan sonraki bes satirda, "hoca" 'nin her sahasina bilgi yaziyoruz. Ilk
  314. saha olan "not", daha once gordugumuz diger structure'lar gibi kullanilir,
  315. cunku ic ice structure taniminda degildir. Daha sonra, bu hocanin yasini
  316. kaydetmek istiyoruz, ve bu ise ic ice structure'da bulunuyor. Bu sahaya
  317. erismek icin, "hoca" degiskeni ile baslayip, "ozellikler" grup ismini
  318. ekliyoruz, ve hangi sahasi ile ilgilendigimizi belirtmek icin, "yas"
  319. ismini de ekliyoruz. "durum" ise ayni "yas" gibi kullanilir, fakat son iki
  320. sahaya deger atama ise, karakter katari olduklarindan, "strcpy" fonksiyonu
  321. ile gerceklestirilir. 
  322.  
  323. "strcpy" nin icindeki degisken isimlerinin, bircok parcadan olusmasina
  324. ragmen, hala degisken isimleri olduguna dikkat edin..
  325.  
  326. "assistan" degiskeni ise, ayni sekilde rastgele bilgilere atanir, fakat
  327. degisik bir sirada. Son olarak bazi "ogrenci" degiskenlerine de atama
  328. yapilir, ve program sona erir. 
  329.  
  330. Bu programi derlediginizde, "stack overflow" hatasi ile
  331. karsilasabilirsiniz. C dili, otomatik degiskenlikleri stack sahasina
  332. gecirerek kullanir, ve cogu derleyici (sayet belirtmezseniz) 2048 byte lik
  333. bir stack sahasi kullanir. Dolayisi ile, stack boyunu degistirmeniz
  334. gerekecektir. Nasil yapilacagi ise, derleyiciden derleyiciye degisir.
  335.  
  336.  
  337. STRUCTURE'LAR HAKKINDA DAHA BILGI
  338.  
  339. Structure'lari, ta ki iyice kafaniz karisincaya kadar ic ice tanimlamak
  340. mumkundur. Duzgun bir sekilde tanimlarsaniz, bilgisayar karistirmaz -
  341. cunku C de buna bir SINIR yoktur. 
  342.  
  343. Structure'lar, baska structure tanimlarindan olusabilir. Bu diger
  344. structure'lar ise, basit degiskenlerden olusmus olabilir. Structure
  345. kullanirken once tutucu, onlari kullanmaya alistikca, daha cesur davranin.
  346.  
  347. UNION NEDIR?
  348.  
  349. UNION1.C:
  350. ================================================================
  351. main()
  352. {
  353. union {
  354.    int deger;     /* Union'un birinci parcasi   */
  355.    struct {
  356.       char ilk;   /* Bu iki deger ise, ikinci.. */
  357.       char ikinci;
  358.    } yarim;
  359. } rakam;
  360.  
  361. long index;
  362.  
  363.    for (index = 12;index < 300000;index += 35231) {
  364.       rakam.deger = index;
  365.       printf("%8x %6x %6x\n",rakam.deger, rakam.yarim.ilk,
  366.           rakam.yarim.ikinci);
  367.    }
  368. }
  369. ================================================================
  370.  
  371. Basitce, bir union sayesinde ayni veriye degisik tipler ile, yada ayni
  372. veriye degisik isimlerle erismenize izin verir. 
  373.  
  374. Bu ornekte, union'un iki parcasi var. Ilki, hafizada iki bytelik bir
  375. degisken olarak saklanan "deger" isimli bir tamsayidir. Ikinci eleman ise,
  376. "ilk" ve "ikinci" isimli iki karakter degiskeninden olusur. Bu iki
  377. degisken, "deger" in saklandigi ayni sahada tutulur - cunku union'un amaci
  378. budur. Bir union ile, hafizada ayni yerde, degisik tip veriler
  379. saklanabilmesini saglar. Bu durumda, "deger" in icine bir tamsayi
  380. koyabilirsiniz, ve bu degeri iki parca halinde "ilk" ve "ikinci" isimli
  381. degiskenler ile alabilirsiniz. Bu teknik genellikle veri bytelarini bir
  382. araya getirip beraber okumak icin kullanilir, ornegin, bir mikroislemcinin
  383. registerlerini beraber okumak icin.
  384.  
  385. Bir union'daki sahalara erismek, bir structure'un sahalarina erismege cok
  386. benzer, ve bunu ornekten incelemeyi size birakiyoruz.
  387.  
  388. Bu program calistiginda cogu derleyici, veriler iki tane f ile baslar
  389. gorunecektir. Bu da, heksadesimal ciktinin, karakter degiskeni integer'a
  390. degistirmesi ve +/- bitini sola kaydirmasi yuzunden olur. Ekrana
  391. gostermeden once "char" veri tiplerini "int" tiplerine degistirmek, "ff"
  392. lere mani olacaktir. Bunu yapmak icin, iki yeni "int" tipi degisken
  393. tanimlamaniz gerekecektir, ve onlara "char" tipi degisken degerleri
  394. atamaniz gerekecektir. 
  395.  
  396. Calistirdiginizda, verinin "int" olarak ve iki tane "char" olarak
  397. yazildigini goreceksiniz. "char" tipi degiskenlerin sirasi
  398. degistirilmistir, cunku hafizada bu sekilde saklanmaktadir. Bu konuyu
  399. kendinize dert etmeyin, fakat incelemek isterseniz, cok ilginc bir konu
  400. olabilir.
  401.  
  402. BIR UNION ORNEGI DAHA
  403.  
  404. UNION2.C:
  405. ================================================================
  406. #define OTO 1
  407. #define TEKNE 2
  408. #define UCAK 3
  409. #define GEMI 4
  410.  
  411. main()
  412. {
  413. struct otomobil {  /* bir otomobil icin structure          */
  414.    int tekerlekler;
  415.    int camurluklar;
  416.    int kapilar;
  417. };
  418.  
  419. typedef struct {     /* bir gemi yada tekne icin structure  */
  420.    int su_kesimi;
  421.    char boyu;
  422. } TEKNEDEF;
  423.  
  424. struct {
  425.    char tasit;         /* ne cins tasit ?                   */
  426.    int agirlik;        /* tasitin gros agirligi             */
  427.    union {             /* tipe-bagimli bilgi                */
  428.       struct otomobil oto;      /* union'un birinci kismi   */
  429.       TEKNEDEF tekne;           /* union'un ikinci kismi    */
  430.       struct {
  431.      char motorlar;
  432.      int kanat_acikligi;
  433.       } ucak;                   /* union'un 3uncu kismi      */
  434.       TEKNEDEF ship;            /* union'un 4uncu kismi      */
  435.    } tasit_tip;
  436.    int deger;            /* tasitin bin TL olarak degeri     */
  437.    char sahibi[32];      /* sahibinin ismi                   */
  438. } ford, sun_fish, piper_cub;   /* 3 structure degiskeni      */
  439.  
  440.        /* birkac sahayi tanimlayalim                         */
  441.  
  442.    ford.tasit = OTO;
  443.    ford.agirlik = 2742;              /* deposu dolu iken      */
  444.    ford.tasit_tip.oto.tekerlekler = 5;  /* istepne dahil      */
  445.    ford.tasit_tip.oto.kapilar = 2;
  446.  
  447.    sun_fish.deger = 3742;           /* trailer haric */
  448.    sun_fish.tasit_tip.tekne.boyu = 5;
  449.  
  450.    piper_cub.tasit = UCAK;
  451.    piper_cub.tasit_tip.ucak.kanat_acikligi = 9;
  452.  
  453.    if (ford.tasit == OTO) /* evet , oyle  */
  454.       printf("Ford'un %d tekerlegi var.\n",ford.tasit_tip.oto.tekerlekler);
  455.  
  456.    if (piper_cub.tasit == OTO) /* hayir,degil */
  457.       printf("Ucagin %d tekerlegi var.\n",piper_cub.tasit_tip.
  458.          oto.tekerlekler);
  459. }
  460. ================================================================
  461.  
  462. Bu ornekte, union'larin cok rastlanilan bir kullanim tarzini goruyorsunuz.
  463. Dusunun ki, bircok tip tasittan olusan bir veri bankasi (veri tabani)
  464. olusturmak istiyoruz. Bir arabadaki pervane sayisi yada bir teknedeki
  465. tekerlek sayisini koymak, komik olurdu. Verimli bir veri tabani olusturmak
  466. icin, bir kismi her cins tasit icin degisik, bir kismi ayni tip kalan
  467. verileri saklamaniz gerekecektir. 
  468.  
  469. Burada, bir structure tanimliyoruz, ve bunun icine gidebilecek degisik
  470. tiplere karar veriyoruz. Ilk once #definelarla, bazi sabitler
  471. tanimliyoruz, daha sonra icindekilerin size hic te yabanci gelmeyecegi
  472. "otomobil" isimli bir structure tanimliyoruz, fakat degisken
  473. tanimlamiyoruz. 
  474.  
  475. TYPEDEF KOMUTU
  476.  
  477. Daha sonra, "typedef" ile yeni bir cins veri tanimliyoruz. Bu da, "int"
  478. yada "char" gibi kullanilabilecek tumuyle yeni bir tip tanimliyoruz.
  479. Structure'un ismi olmadigini, fakat degisken tanimlanacagi yerde,
  480. "TEKNEDEF" ismini goruyorsunuz. Artik, "TEKNEDEF" diye bir tipimiz vardir,
  481. ve bununla istedigimiz heryerde bir structure tanimlayabiliriz. Bu komut,
  482. degisken tanimlamasi yapmiyor, fakat sadece tipi tanimliyor.
  483.  
  484. Buyuk harf kullanmak sadece sahsi tercih icindir, fakat bir C standarti
  485. degildir. Sadece, "typedef" i, bir degisken isiminden ayri tutmaktadir.
  486.  
  487. Daha once yarattigimiz parcalari kullanan buyuk kesime geldik. Bu
  488. structure, 5 parcadan olusmustur, iki "tasit" ve "agirlik" isimli basit
  489. degisken, bir union, ve "deger" ve "sahibi" isimli iki basit degisken
  490. daha. Tabii ki, burada onemle bakmamiz gereken, union tanimlanmasidir. 
  491.  
  492. Bakinca, bunun 4 parcadan olustugunu goreceksiniz. Ilk parcasi "oto"
  493. isimli, ve daha once tanimladigimiz bir tipte olan degiskendir. Ikinci
  494. kismi, "tekne" ismindedir, ve daha once tanimladigimiz "TEKNEDEF"
  495. tipindedir. Ucuncu kesimi ise, "ucak" isimli, ve union icinde tanimlanan
  496. bir structure'dur. Sonunda, union'un en son parcasi olan "gemi" isimli
  497. degisken de "TEKNEDEF" tipindedir. 
  498.  
  499. Umarim bu dordunun gosterilen 3 mettoddan biri ile tanimlanabilecegi,
  500. sizin icin aciktir. Normalde, herhalde en "temiz" tanim, her birinin
  501. "typedef" ile tanimlanmasi sayesinde olacaktir. 
  502.  
  503. SIMDI NE OLDU?
  504.  
  505. Simdi, icine dort cins veri saklayabilecegimiz bir yapimiz var. Her
  506. kayitin uzunlugu, en buyuk union'u tasiyan kayitin uzunlugunda olacaktir.
  507. Bu durumda, birinci kesim, en buyugudur, cunku 3 tamsayi degiskeninden
  508. olusmaktadir. Digerleri ise, bir karakter ve bir tamsayidan
  509. olusmaktadirlar. Yani, bu union'un ilk parcasi, bu tipteki butun
  510. structure'larin boyunu belirleyecektir. Elde edilen structure, her dort
  511. tip veriden birini saklamasi icin kullanilabilir, fakat bu tip bir bir
  512. degiskenin icinde neler saklandigini kontrol etmek, programcinin isidir.
  513. "tasit" isimli degisken, orada ne tip bir tasit saklandigini belirtmek
  514. icin kullanilmistir. Programin basindaki dort #define satiri, "tasit" in
  515. icinde saklanabilecekleri belirtir. 
  516.  
  517. Ortaya cikan yapinin kullanimini gostermek icin,  birkac ornek de vardir.
  518. Bazi degiskenlere degerler atanmis, birkac tanesinin degeri ekrana
  519. yazilmistir. 
  520.  
  521. Union'lar, hele yeni programlamaya baslayanlar tarafindan, cok SIK
  522. kullanilmaz. Bazen rastlayabilirsiniz, ve ne ise yaradiklarini bilmenizde
  523. fayda vardir. Su an icin detaylarini ogrenmenize luzum yoktur, ve bu
  524. nedenle, bu ornekte fazla vakit harcamayin. Sayet bir gun saha tanimlari
  525. degisen bir yapiya ihtiyaciniz olursa, o zaman ogrenebilirsiniz. Fakat
  526. kendi igiliginiz icin, structure'lara alismaya bakin - onlar daha SIK
  527. kullanilirlar. 
  528.  
  529. ODEV
  530.  
  531. 1. Icinde "isim" icin bir karakter dizisi, "ayaklar" icin bir tamsayi
  532. degiskeni, ve "kollar" icin bir baska tamsayi degiskeni olan ISIMLI bir
  533. structure tanimlayin. Bu structure ile, 6 elemanlik bir dizin tanimlayin.
  534. Bu sahanin icine, degisik bilgiler atayin, ve ekrana suna benzer bir cikti
  535. saglayin:
  536.  
  537. Bir insanin 2 kolu ve 2 ayagi vardir.
  538. Bir kopegin 0 kolu ve 4 ayagi vardir.
  539. Bir televizyonun 0 kolu ve 4 ayagi vardir.
  540. Bir sandalyenin 2 kolu ve 4 ayagi vardir.
  541. vs.
  542.  
  543.  
  544. 2. Birinci programi tekrar yazip, verileri ekrana yazmak icin bir
  545. pointer'dan yararlanin.
  546.  
  547. <EOF>
  548.